FEXPCommon.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Library for the common use.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPCOMMON_H_
#define _CFEXPCOMMON_H_
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cwchar>
#include <cstddef>
#include <memory>
#include <numeric>
#include <locale>
#include <utility>
#include <sstream>
#include <stdarg.h>
#include <functional>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <iostream>
#include <fstream>
#include <filesystem>
#include <io.h>
#include <iomanip>
#include <climits>
#include <algorithm>
#include <chrono>
#include <ctime>
#include <typeinfo>
#include <type_traits>
#include <cmath>
#include <array>
#include <typeinfo>
#include <typeindex>
#include <exception>
#include <thread>
#include <future>
#include <mutex>
#include <condition_variable>
#include <chrono>

// --> Console
#define FEXPCOMMON_CONSOLE_OUT             std::cout

#define FEXPCOMMON_CONSOLE_SAFE_THREAD_OUT CFEXPSafeConcurencyConsolePrint{ }
#define FEXPCOMMON_CONSOLE_PAUSE(manager)  if(!manager) system("PAUSE")

// --> Command line content
// cmd line content
#define FEXPCOMMON_CMD_EXE_PATH_INDEX    0
#define FEXPCOMMON_CMD_MANAGER_INDEX     1
#define FEXPCOMMON_CMD_SERVER_IP_INDEX   2
#define FEXPCOMMON_CMD_SERVER_PORT_INDEX 3
#define FEXPCOMMON_CMD_MAX_LENGTH        4
#define FEXPCOMMON_CMD_MIN_LENGTH        2

// --> Windows specifics
#include <Winsock2.h>
#include <Ws2tcpip.h>
// Windows versions constants
#define FEXPCOMMON_WIN_VISTA NTDDI_VISTA
#define FEXPCOMMON_WIN_7     NTDDI_WIN7
#define FEXPCOMMON_WIN_8     NTDDI_WIN8
#define FEXPCOMMON_WIN_10    NTDDI_WIN8 // Win 10 and 8 compatible
// current Win. OS version used for compilation
#define FEXPCOMMON_MY_WIN_VERSION_FOR_COMPILATION FEXPCOMMON_WIN_7 // development version of windows

namespace FEXPFEDefinition
{
  enum EFEXPFiniteElementGeom
  {
    eNotDef,
    // 1D finite elements in 2D space
    eFE_1D_in2D,
    // 2D finite elements in 2D space
    eFE_2D_in2D,
    // 2D finite elements in 3D space
    eFE_2D_in3D,
    // 3D finite elements
    eFE_3D,
    eFECount
  };

  enum EFEXPFiniteElementType
  {
    eNoElement     = 0,
    // triangular 3-noded shell finite element
    eFeShellTriag     ,
    // triangular 8-noded brick finite element
    eFeBrickSolidTriag,
    eFeCount
  };
}

using t_fexpcommon_ct = double;

// macro for load of string key for respective block of base inp. data file structure
#define STRUCT_KEYS(fstrct, eidntfier) fstrct[(eidntfier)]
// lazy allocation inp. file data class block
#define LAZY_ALLC(alloclass, baseclass) []()->Ptr<baseclass> { return CFEXPDataManager<alloclass>::SafeAllocInstance(); }
// identifier of file block (enumerator)
#define CLS_KEY(alloclass) alloclass::ID
// macro for creation of pair block key <--> allocator for inp. file class
#define CLS_MAP_PAIR(fstrct, alloclass, baseclass) { STRUCT_KEYS(fstrct, CLS_KEY(alloclass)), LAZY_ALLC(alloclass, baseclass) }

#define FEXPCOMMON_STACAST(clsfrom, clsto, variable) Ptr<clsfrom>::SafeSmartPtrStatCast<clsto>(variable)
#define FEXPCOMMON_DYNCAST(clsfrom, clsto, variable) Ptr<clsfrom>::SafeSmartPtrDnmcCast<clsto>(variable)

// --> Macros for throwing the custom exception
#define FEXPCOMMON_EXCEPTION(error_text) throw std::runtime_error(error_text)
#define FEXPCOMMON_NOT_IMPLEMENTED_EX FEXPCOMMON_EXCEPTION("Not implemented!!!")

#undef min // disconnect min from stdlib header
#undef max // disconnect max from stdlib header
#define FEXPCOMMON_MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define FEXPCOMMON_MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
#define FEXPCOMMON_FOREACH(start, end, index) for(index = (start); index <= (end); ++index)
#define FEXPCOMMON_FOREACH_REV(start, end, index) for(index = (start); index >= (end); --index)
#define IT current_item_for_each
#define FEXPCOMMON_FOREACH_ITER(data) for (auto IT = (data).begin(); IT != (data).end(); ++IT)
#define FEXPCOMMON_FOREACH_ITER_FNC(data, lambda_body) std::for_each((data).begin(), (data).end(), [&](auto IT) lambda_body)

#define FEXPCOMMON_BUFFER_LINE_LEN                                            1024 // maximal length of string buffer
#define FEXPCOMMON_MIN_VALUE                                                1.0E-6 // minimum value
#define FEXPCOMMON_FLT_PRECISION                                            1.0E-7 // precision of float
#define FEXPCOMMON_FLT_PRECISION_DIGITS                                          7 // precision of float
#define FEXPCOMMON_FLT_MAX              (std::numeric_limits<float>::max()  / 2.0) // max value of float (only half of it)
#define FEXPCOMMON_DBL_PRECISION                                           1.0E-15 // precision of double
#define FEXPCOMMON_DBL_PRECISION_DIGITS                                         15 // precision of double
#define FEXPCOMMON_DBL_MAX              (std::numeric_limits<double>::max() / 2.0) // max value of double (only half of it)
#define FEXPCOMMON_INVALID_INDX                                                 -1 // invalid index value
#define FEXPCOMMON_DEFAULT_INDX                                                  0 // default index value
#define FEXPCOMMON_PI                                       3.14159265358979323846  
#define FEXPCOMMON_NO_VALUE_STR                                         "No value"

#define FEXPCOMMON_MAXFLDS                                                      10 // maximum possible number of fields
#define FEXPCOMMON_MAXFLDSIZE                                                   32 // longest possible field + 1 = 31 byte field
#define FEXPCOMMON_EMPTY                                                         0 // default length
#define FEXPCOMMON_DEFAULT_VALUE                                                 0
#define FEXPCOMMON_DELIMITER                                                   ";" // input file item row delimiter 
#define FEXPCOMMON_KEY_BLOCK_IDNTF                                             "#"
#define FEXPCOMMON_KEY_TABLE_IDNTF                                             "$"
#define FEXPCOMMON_EMPTY_STRING                                                 ""
#define FEXPCOMMON_EMCHR_STRING                                                " "
#define FEXPCOMMON_NEW_LINE                                                   "\n"
#define FEXPCOMMON_QUEST_MARK_CHAR                                             '?'
#define FEXPCOMMON_ZERO_END_CHAR                                              '\0'
#define FEXPCOMMON_ZERO_END_WCHAR                                            L'\0'
#define FEXPCOMMON_DFLT_TXT          (std::string("@FEXP") + FEXPCOMMON_DELIMITER)

#define FEXPCOMMON_DATA_TYPE(type) std::type_index(typeid(type))
#define FEXPCOMMON_DATA_TYPE_NAME(type) FEXPCOMMON_DATA_TYPE(type).name()
// type index of common types
#define FEXPCOMMON_CLCFLT_TYPE      FEXPCOMMON_DATA_TYPE(t_fexpcommon_ct)
#define FEXPCOMMON_SIZE_T_TYPE      FEXPCOMMON_DATA_TYPE(size_t         )
#define FEXPCOMMON_STRING_TYPE      FEXPCOMMON_DATA_TYPE(std::string    )
// data type represantation of used types
#define FEXPCOMMON_CLCFLT_TYPE_NAME FEXPCOMMON_DATA_TYPE_NAME(t_fexpcommon_ct)
#define FEXPCOMMON_SIZE_T_TYPE_NAME FEXPCOMMON_DATA_TYPE_NAME(size_t         )
#define FEXPCOMMON_STRING_TYPE_NAME FEXPCOMMON_DATA_TYPE_NAME(std::string    )


#define GET_MAX_FLT_VAL(type) \
((FEXPCOMMON_DATA_TYPE_NAME(type) == FEXPCOMMON_DATA_TYPE_NAME(float)) ?\
FEXPCOMMON_FLT_MAX : FEXPCOMMON_DBL_MAX)

#define GET_MIN_FLT_VAL(type) \
((FEXPCOMMON_DATA_TYPE_NAME(type) == FEXPCOMMON_DATA_TYPE_NAME(float)) ?\
FEXPCOMMON_FLT_PRECISION : FEXPCOMMON_DBL_PRECISION)

#define GET_FLT_PRECIS_DIGIT(type) \
((FEXPCOMMON_DATA_TYPE_NAME(type) == FEXPCOMMON_DATA_TYPE_NAME(float)) ?\
FEXPCOMMON_FLT_PRECISION_DIGITS : FEXPCOMMON_DBL_PRECISION_DIGITS)

#define GET_MAX_SIZE_T_VAL() std::numeric_limits<size_t>::max()

template <typename TFunc>
struct cfexp_is_fun_ptr
  : std::integral_constant<bool,
  std::is_pointer<TFunc>::value &&
  std::is_function<typename std::remove_pointer<TFunc>::type>::value>{ };

template <typename TClassType>
struct function_traits
  : public function_traits<decltype(&TClassType::operator())>{ };

template <typename TClassType, typename TReturnType, typename... Args>
struct function_traits<TReturnType(TClassType::*)(Args...) const>
{
  //enum { arity = sizeof...(Args) };
  typedef std::function<TReturnType(Args...)> f_type;
};

template <typename TClassType, typename TReturnType, typename... Args>
struct function_traits<TReturnType(TClassType::*)(Args...)>
{
  typedef std::function<TReturnType(Args...)> f_type;
};

template <typename TReturnType, typename... Args>
struct function_traits<TReturnType(*)(Args...)>
{
  typedef std::function<TReturnType(Args...)> f_type;
};

template <typename TLambda>
typename function_traits<TLambda>::f_type make_function(TLambda value)
{
  return (typename function_traits<TLambda>::f_type)(value);
}


template<typename TType> class CFEXPDataManager;
template<typename TType>
class CFEXPSmartPointer : public std::shared_ptr<TType>
{
public:
  CFEXPSmartPointer() : std::shared_ptr<TType>() { _arr_length = FEXPCOMMON_EMPTY; }
  CFEXPSmartPointer(const std::shared_ptr<TType> & source);
  CFEXPSmartPointer(const std::shared_ptr<TType> & source, size_t arr_length);
  virtual ~CFEXPSmartPointer() { }

  // overloaded operators
  CFEXPSmartPointer<TType> & operator=(const CFEXPSmartPointer<TType> & source);

  // method for safe cast
  template<typename TTo>
  static CFEXPSmartPointer<TTo> SafeSmartPtrStatCast(const CFEXPSmartPointer<TType> & from);
  template<typename TTo>
  static CFEXPSmartPointer<TTo> SafeSmartPtrDnmcCast(const CFEXPSmartPointer<TType> & from);

  // extended methods for base class
  CFEXPSmartPointer<TType> MakeClone   () const;
  void                     SetToNull   ()       { reset();            }
  size_t                   GetArrLength() const { return _arr_length; }
protected:
  // [no protected members] -----------------------------
private:
  // it holds the length of an allocated array
  size_t _arr_length;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TType>
CFEXPSmartPointer<TType>::CFEXPSmartPointer(const std::shared_ptr<TType> & source)
  : std::shared_ptr<TType>(source), _arr_length(FEXPCOMMON_EMPTY) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TType>
CFEXPSmartPointer<TType>::CFEXPSmartPointer(const std::shared_ptr<TType> & source, size_t arr_length)
  : std::shared_ptr<TType>(source), _arr_length(arr_length) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TType>
CFEXPSmartPointer<TType> & CFEXPSmartPointer<TType>::operator=(const CFEXPSmartPointer<TType> & source)
//--------------------------------------------------------------------------------------
{
  std::shared_ptr<TType>::operator=(source);
  _arr_length = source._arr_length;
  return *this;
}

//--------------------------------------------------------------------------------------
template<typename TType> template<typename TTo>
CFEXPSmartPointer<TTo> CFEXPSmartPointer<TType>::SafeSmartPtrStatCast(const CFEXPSmartPointer<TType> & from)
//--------------------------------------------------------------------------------------
{
  return from ?
    std::static_pointer_cast<TTo>(from) :
    CFEXPSmartPointer<TTo>();
}

//--------------------------------------------------------------------------------------
template<typename TType> template<typename TTo>
CFEXPSmartPointer<TTo> CFEXPSmartPointer<TType>::SafeSmartPtrDnmcCast(const CFEXPSmartPointer<TType> & from)
//--------------------------------------------------------------------------------------
{
  return from ?
    std::dynamic_pointer_cast<TTo>(from) :
    CFEXPSmartPointer<TTo>();
}

//--------------------------------------------------------------------------------------
template<typename TType>
CFEXPSmartPointer<TType> CFEXPSmartPointer<TType>::MakeClone() const
//--------------------------------------------------------------------------------------
{
  return *this ?
    CFEXPDataManager::SafeAllocInstance(std::reference_wrapper<const TType>(*get())) :
    CFEXPSmartPointer();
}

// special typedef for smart pointer
template<typename TType>
using Ptr = CFEXPSmartPointer<TType>;


template<typename TType>
class CFEXPDataManager
{
public:
  template<typename ...VarArgs>
  static Ptr<TType> SafeAllocInstance         (VarArgs &&... inpar);
  static Ptr<TType> MakeAllocInstanceSafe     (TType * alloc);
  static Ptr<TType> SafeAllocInstanceArray    (size_t length);
  static Ptr<TType> MakeAllocInstanceArraySafe(TType * alloc, size_t length);
  virtual ~CFEXPDataManager() { }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// member functions

//--------------------------------------------------------------------------------------
template<typename TType> template<typename ...VarArgs>
Ptr<TType> CFEXPDataManager<TType>::SafeAllocInstance(VarArgs &&... inpar)
//--------------------------------------------------------------------------------------
{
  return std::make_shared<TType>(std::forward<VarArgs>(inpar)...);
}

//--------------------------------------------------------------------------------------
template<typename TType>
Ptr<TType> CFEXPDataManager<TType>::MakeAllocInstanceSafe(TType * alloc)
//--------------------------------------------------------------------------------------
{
  return Ptr<TType>(std::shared_ptr<TType>(alloc));
}

//--------------------------------------------------------------------------------------
template<typename TType>
Ptr<TType> CFEXPDataManager<TType>::SafeAllocInstanceArray(size_t length)
//--------------------------------------------------------------------------------------
{
  return Ptr<TType>(std::shared_ptr<TType>(new TType[length],
    std::default_delete<TType[]>()), length);
}

//--------------------------------------------------------------------------------------
template<typename TType>
Ptr<TType> CFEXPDataManager<TType>::MakeAllocInstanceArraySafe(TType * alloc, size_t length)
//--------------------------------------------------------------------------------------
{
  return Ptr<TType>(std::shared_ptr<TType>(alloc), length);
}


template<typename TData, typename TKey>
class ICFEXPDataWrapperBase
{
public:
  ICFEXPDataWrapperBase<TData, TKey>(Ptr<TData> & data);
  ICFEXPDataWrapperBase<TData, TKey>(const ICFEXPDataWrapperBase & source);
  virtual ~ICFEXPDataWrapperBase() { }

  Ptr<TData> GetData() { return _data; }
  // pure virtual member functions
  virtual TKey GetKey () = 0;
protected:
  Ptr<TData> _data;
private:
  // [no private members] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData, typename TKey>
ICFEXPDataWrapperBase<TData, TKey>::ICFEXPDataWrapperBase(Ptr<TData> & data)
  : _data(data) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TData, typename TKey>
ICFEXPDataWrapperBase<TData, TKey>::ICFEXPDataWrapperBase(const ICFEXPDataWrapperBase & source)
  : _data(source._data) { }
//--------------------------------------------------------------------------------------

// std::map pair creation
#define MAP_PAIR(key, itm) std::make_pair(key, itm)

// primary template
template<typename TWrapper, typename TData, typename TKey, typename Enable = void>
class ICFEXPDataContainerBase { };
template<typename TWrapper, typename TData, typename TKey>
class ICFEXPDataContainerBase
  // specialization
  <TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
{
public:
  ICFEXPDataContainerBase();
  virtual ~ICFEXPDataContainerBase();

  bool AddData       (Ptr<TData>    & item);
  bool AddWrappedData(Ptr<TWrapper> & item);

  template<typename TDataSpec>
  typename std::enable_if<std::is_base_of<TData, TDataSpec>::value, Ptr<TDataSpec>>::type
  GetData();
  Ptr<TData>    GetData       (const TKey & key);
  Ptr<TWrapper> GetWrappedData(const TKey & key);

  bool   Contains(const TKey & key);
  bool   Remove  (const TKey & key);
  void   Clear   ();
  size_t Count   ();
  bool   Empty   ();

  // pure virtual member functions
  virtual std::string GetContainerName() const = 0;
protected:
  std::map<TKey, Ptr<TWrapper>> & get_container();
private:
  std::map<TKey, Ptr<TWrapper>> _container;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::ICFEXPDataContainerBase() { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::~ICFEXPDataContainerBase()
//--------------------------------------------------------------------------------------
{
  Clear();
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
bool ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::Contains(const TKey & key)
//--------------------------------------------------------------------------------------
{
  return bool(get_container().count(key));
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
bool ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::Remove(const TKey & key)
//--------------------------------------------------------------------------------------
{
  if (!Contains(key))
    return false;
  get_container().erase(get_container().find(key));
  return true;
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
bool ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::AddData(Ptr<TData> & item)
//--------------------------------------------------------------------------------------
{
  return AddWrappedData(CFEXPDataManager<TWrapper>::SafeAllocInstance(item));
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
bool ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::AddWrappedData(Ptr<TWrapper> & item)
//--------------------------------------------------------------------------------------
{
  auto result = false;
  if (!item)
    return result;

  auto key = item->GetKey();
  if (Contains(key))
    return result;

  // is need for some compilers
  //auto cast = FEXPCOMMON_STACAST(TWrapper, ICFEXPDataWrapperBase<TData, TKey>, item);
  get_container().insert(MAP_PAIR(key, item));
  return !result;
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey> template<typename TDataSpec>
typename std::enable_if<std::is_base_of<TData, TDataSpec>::value, Ptr<TDataSpec>>::type
ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::GetData()
//--------------------------------------------------------------------------------------
{
  auto cast = Ptr<TDataSpec>();
  FEXPCOMMON_FOREACH_ITER(get_container())
  {
    auto ptr = (*IT).second->GetData();
    if (!FEXPCOMMON_DYNCAST(TData, TDataSpec, ptr))
      continue;
    cast = FEXPCOMMON_STACAST(TData, TDataSpec, ptr);
    break;
  }
  return cast;
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
Ptr<TData>  ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::GetData(const TKey & key)
//--------------------------------------------------------------------------------------
{
  auto data = GetWrappedData(key);
  return data ? data->GetData() : Ptr<TData>();
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
Ptr<TWrapper>  ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::GetWrappedData(const TKey & key)
//--------------------------------------------------------------------------------------
{
  return Contains(key) ? get_container()[key] : Ptr<TWrapper>();
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
void ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::Clear()
//--------------------------------------------------------------------------------------
{
  get_container().clear();
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
size_t ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::Count()
//--------------------------------------------------------------------------------------
{
  return get_container().size();
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
bool ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::Empty()
//--------------------------------------------------------------------------------------
{
  return get_container().empty();
}

//--------------------------------------------------------------------------------------
template<typename TWrapper, typename TData, typename TKey>
std::map<TKey, Ptr<TWrapper>> & ICFEXPDataContainerBase<TWrapper, TData, TKey,
  typename std::enable_if<std::is_base_of<ICFEXPDataWrapperBase<TData, TKey>, TWrapper>::value>::type>
  ::get_container()
//--------------------------------------------------------------------------------------
{
  return _container;
}


template <typename TValue>
class ICFEXPMatrixBufferBase
{
public:
  ICFEXPMatrixBufferBase(size_t length, std::function<TValue(size_t)> default_val) :
    _length(length), _default_value(default_val) { }
  virtual ~ICFEXPMatrixBufferBase() { }

  // pure virtual member functions 
  virtual void   SetValue(size_t index, TValue value) = 0;
  virtual TValue GetValue(size_t index)               = 0;
  virtual bool   IsBufferReady()                      = 0;

  size_t GetBufferLength() { return _length; }
protected:
  // default value getter
  std::function<TValue(size_t)> _default_value;
private:
  size_t                        _length;
};


template <typename TValue>
class CFEXPMatrixBufferArray
  : public ICFEXPMatrixBufferBase<TValue>
{
public:
  CFEXPMatrixBufferArray(size_t length, std::function<TValue(size_t)> default_val);
  virtual ~CFEXPMatrixBufferArray() { }

  // override virtual member functions 
  virtual void   SetValue(size_t index, TValue value) override { _buffer.get()[index] = value; };
  virtual TValue GetValue(size_t index)               override { return _buffer.get()[index]; };
  virtual bool   IsBufferReady()                      override { return _buffer; };
protected:
  // [no protected members] -----------------------------
private:
  Ptr<TValue> _buffer;
};

// member functions
//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPMatrixBufferArray<TValue>::CFEXPMatrixBufferArray(size_t length, std::function<TValue(size_t)> default_val)
  : ICFEXPMatrixBufferBase<TValue>(length, default_val),
  _buffer(CFEXPDataManager<TValue>::SafeAllocInstanceArray(GetBufferLength()))
//--------------------------------------------------------------------------------------
{
  if (!default_val)
    return;
  size_t indx;
  FEXPCOMMON_FOREACH(FEXPCOMMON_DEFAULT_INDX, _buffer.GetArrLength(), indx)
    SetValue(indx, _default_value(indx));
}


template <typename TValue>
class CFEXPMatrixBufferStdVector
  : public ICFEXPMatrixBufferBase<TValue>
{
public:
  CFEXPMatrixBufferStdVector(size_t length, std::function<TValue(size_t)> default_val);
  virtual ~CFEXPMatrixBufferStdVector() { }

  // override virtual member functions 
  virtual void   SetValue(size_t index, TValue value) override { _buffer->at(index) = value; };
  virtual TValue GetValue(size_t index)               override { return _buffer->at(index);  };
  virtual bool   IsBufferReady()                      override { return bool(_buffer);       };
protected:
  // [no protected members] -----------------------------
private:
  Ptr<std::vector<TValue>> _buffer;
};

// member functions
//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPMatrixBufferStdVector<TValue>::CFEXPMatrixBufferStdVector(size_t length, std::function<TValue(size_t)> default_val)
  : ICFEXPMatrixBufferBase<TValue>(length, default_val),
  _buffer(CFEXPDataManager<std::vector<TValue>>::SafeAllocInstance(GetBufferLength()))
//--------------------------------------------------------------------------------------
{
  if (!default_val)
    return;
  size_t indx;
  FEXPCOMMON_FOREACH(FEXPCOMMON_DEFAULT_INDX, _buffer->size() - 1, indx)
    SetValue(indx, _default_value(indx));
}


template <typename TValue>
class CFEXPMatrixBufferStdMap
  : public ICFEXPMatrixBufferBase<TValue>
{
public:
  CFEXPMatrixBufferStdMap(size_t length, std::function<TValue(size_t)> default_val);
  virtual ~CFEXPMatrixBufferStdMap() { }

  // override virtual member functions 
  virtual void   SetValue(size_t index, TValue value) override;
  virtual TValue GetValue(size_t index)               override;
  virtual bool   IsBufferReady()                      override { return _buffer; };
protected:
  // [no protected members] -----------------------------
private:
  size_t                        _length;
  Ptr<std::map<size_t, TValue>> _buffer;
};

// member functions
//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPMatrixBufferStdMap<TValue>::CFEXPMatrixBufferStdMap(size_t length, std::function<TValue(size_t)> default_val)
  : ICFEXPMatrixBufferBase<TValue>(length, default_val),
  _buffer(CFEXPDataManager<std::map<size_t, TValue>>::SafeAllocInstance()) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template <typename TValue>
void CFEXPMatrixBufferStdMap<TValue>::SetValue(size_t index, TValue value)
//--------------------------------------------------------------------------------------
{
  if (index >= _length)
    FEXPCOMMON_EXCEPTION("Error: Index is out of buffer length!!!");
  _buffer->at(index) = value;
}

//--------------------------------------------------------------------------------------
template <typename TValue>
TValue CFEXPMatrixBufferStdMap<TValue>::GetValue(size_t index)
//--------------------------------------------------------------------------------------
{ 
  // check if index has been already set
  if (!_buffer->count(index))
    return _default_value(index);
  return _buffer->at(index);
}

// primary template
template<template<typename> typename TBuffer, typename TValue, typename Enable = void>
class CFEXPMatrixBase { };
template<template<typename> typename TBuffer, typename TValue>
class CFEXPMatrixBase
  // specialization
  <TBuffer, TValue, typename std::enable_if<std::is_base_of<ICFEXPMatrixBufferBase<TValue>, TBuffer<TValue>>::value>::type>
{
public:
  CFEXPMatrixBase(size_t length, std::function<TValue(size_t)> default_val);
  virtual ~CFEXPMatrixBase() { }

  bool   SetValue(size_t index, TValue value);
  TValue GetValue(size_t index);

  // pure virtual member functions
  virtual std::string Serialize  ()                         = 0;
  virtual void        Deserialize(const std::string & data) = 0;
protected:
  // [no protected members] -----------------------------
private:
  Ptr<TBuffer<TValue>> _buffer;
};

// member functions
//--------------------------------------------------------------------------------------
template<template<typename> typename TBuffer, typename TValue>
CFEXPMatrixBase<TBuffer, TValue, typename std::enable_if<std::is_base_of<ICFEXPMatrixBufferBase<TValue>, TBuffer<TValue>>::value>::type>
  ::CFEXPMatrixBase(size_t length, std::function<TValue(size_t)> default_val)
  : _buffer(CFEXPDataManager<TBuffer<TValue>>::SafeAllocInstance(length, default_val)) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<template<typename> typename TBuffer, typename TValue>
bool CFEXPMatrixBase<TBuffer, TValue, typename std::enable_if<std::is_base_of<ICFEXPMatrixBufferBase<TValue>, TBuffer<TValue>>::value>::type>
  ::SetValue(size_t index, TValue value)
//--------------------------------------------------------------------------------------
{
#define MATRIX_ERROR_SET "Error: Matrix is not initialized: \"Set Action\"!!!"
  if (!_buffer || !_buffer->IsBufferReady())
    FEXPCOMMON_EXCEPTION(MATRIX_ERROR_SET);

  auto result = true;
  if (index >= _buffer->GetBufferLength())
    return !result;

  _buffer->SetValue(index, value);
  return result;
}

//--------------------------------------------------------------------------------------
template<template<typename> typename TBuffer, typename TValue>
TValue CFEXPMatrixBase<TBuffer, TValue, typename std::enable_if<std::is_base_of<ICFEXPMatrixBufferBase<TValue>, TBuffer<TValue>>::value>::type>
  ::GetValue(size_t index)
//--------------------------------------------------------------------------------------
{
#define MATRIX_ERROR_GET "Error: Matrix is not initialized: \"Get Action\"!!!"
  if (!_buffer || !_buffer->IsBufferReady())
    FEXPCOMMON_EXCEPTION(MATRIX_ERROR_GET);

  return _buffer->GetValue(index);
}


template <typename TValue>
class CFEXPGeneralMatrix2DVect
  : public CFEXPMatrixBase<CFEXPMatrixBufferStdVector, TValue>
{
public:
  CFEXPGeneralMatrix2DVect(size_t rows, size_t cols, std::function<TValue(size_t)> default_val);
  virtual ~CFEXPGeneralMatrix2DVect() { }

  bool   SetValue (size_t row, size_t col, TValue value);
  TValue GetValue (size_t row, size_t col);
  // get and set value of transpose matrix
  bool   SetValueT(size_t row, size_t col, TValue value);
  TValue GetValueT(size_t row, size_t col);

  // dimensions of 2D matrix
  size_t GetRows() const { return _rows; }
  size_t GetCols() const { return _cols; }
protected:
  // [no protected members] -----------------------------
private:
  size_t _rows;
  size_t _cols;
  size_t get_array_length(size_t rows, size_t cols) const;
  size_t get_array_index (size_t row , size_t col ) const;
};

// member functions
//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPGeneralMatrix2DVect<TValue>::CFEXPGeneralMatrix2DVect(size_t rows, size_t cols, std::function<TValue(size_t)> default_val)
  : CFEXPMatrixBase<CFEXPMatrixBufferStdVector, TValue>(get_array_length(rows, cols), default_val), _rows(rows), _cols(cols) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template <typename TValue>
bool CFEXPGeneralMatrix2DVect<TValue>::SetValue(size_t row, size_t col, TValue value)
//--------------------------------------------------------------------------------------
{
  return CFEXPMatrixBase<CFEXPMatrixBufferStdVector, TValue>::SetValue(get_array_index(row, col), value);
}

//--------------------------------------------------------------------------------------
template <typename TValue>
TValue CFEXPGeneralMatrix2DVect<TValue>::GetValue(size_t row, size_t col)
//--------------------------------------------------------------------------------------
{
  return CFEXPMatrixBase<CFEXPMatrixBufferStdVector, TValue>::GetValue(get_array_index(row, col));
}

template <typename TValue>
//--------------------------------------------------------------------------------------
bool CFEXPGeneralMatrix2DVect<TValue>::SetValueT(size_t row, size_t col, TValue value)
//--------------------------------------------------------------------------------------
{
  return SetValue(col, row, value);
}

template <typename TValue>
//--------------------------------------------------------------------------------------
TValue CFEXPGeneralMatrix2DVect<TValue>::GetValueT(size_t row, size_t col)
//--------------------------------------------------------------------------------------
{
  return GetValue(col, row);
}

//--------------------------------------------------------------------------------------
template <typename TValue>
size_t CFEXPGeneralMatrix2DVect<TValue>::get_array_length(size_t rows, size_t cols) const
//--------------------------------------------------------------------------------------
{
  return rows * cols;
}

//--------------------------------------------------------------------------------------
template <typename TValue>
size_t CFEXPGeneralMatrix2DVect<TValue>::get_array_index(size_t row, size_t col) const
//--------------------------------------------------------------------------------------
{
  return row * _cols + col;
}


class CFEXPMatrix2D
  : public CFEXPGeneralMatrix2DVect<t_fexpcommon_ct>
{
public:
  CFEXPMatrix2D(size_t rows, size_t cols)
    : CFEXPGeneralMatrix2DVect<t_fexpcommon_ct>(rows, cols,
      std::function<t_fexpcommon_ct(size_t)>() /*[&](size_t idx)->t_fexpcommon_ct {return FEXPCOMMON_DEFAULT_VALUE; }*/) { }
  virtual ~CFEXPMatrix2D() { }

  // override pure virtual member functions
  virtual std::string Serialize  ()                         override;
  virtual void        Deserialize(const std::string & data) override;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPBaseConvers
{
public:
  static std::string WCharToStringASCII(const wchar_t* toconvert, const char vicchar = FEXPCOMMON_QUEST_MARK_CHAR, std::locale & local = std::locale());
  static std::vector<std::string> SplitString(const std::string & str, const std::string & delim);
  template<typename TValue>
  typename std::enable_if<std::is_arithmetic<TValue>::value, TValue>::type
  static StringToNumber(const std::string & strnum);
  static std::string & CFEXPBaseConvers::StrLtrim(std::string & str);
  static std::string & CFEXPBaseConvers::StrRtrim(std::string & str);
  static std::string & CFEXPBaseConvers::StrTrim (std::string & str);
  template<typename TValue>
  typename std::enable_if<std::is_arithmetic<TValue>::value, std::string>::type
  static NumberToString(TValue value);
  template<typename TValue>
  typename std::enable_if<std::is_floating_point<TValue>::value, int>::type
  static Compare(TValue value1, TValue value2, TValue eps = FEXPCOMMON_DEFAULT_VALUE);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TValue>
typename std::enable_if<std::is_arithmetic<TValue>::value, TValue>::type
CFEXPBaseConvers::StringToNumber(const std::string & strnum)
//--------------------------------------------------------------------------------------
{
  try
  {
    TValue value;
    std::stringstream stream(strnum);
    stream >> value;
    if (stream.fail())
      FEXPCOMMON_EXCEPTION(strnum);
    return value;
  }
  catch (const std::exception&)
  {
    return 0;
  } 
}

//--------------------------------------------------------------------------------------
template<typename TValue>
typename std::enable_if<std::is_arithmetic<TValue>::value, std::string>::type
CFEXPBaseConvers::NumberToString(TValue value)
//--------------------------------------------------------------------------------------
{
  std::ostringstream stream;
  if (FEXPCOMMON_DATA_TYPE_NAME(TValue) == FEXPCOMMON_CLCFLT_TYPE_NAME)
  {
    stream.precision(GET_FLT_PRECIS_DIGIT(TValue));
    stream << std::scientific << value;
  }
  else
    stream << value;
  return stream.str();
}

#define FEXPCOMMON_COMPARE_EQ  0
#define FEXPCOMMON_COMPARE_1V  1
#define FEXPCOMMON_COMPARE_2V  2
//--------------------------------------------------------------------------------------
template<typename TValue>
typename std::enable_if<std::is_floating_point<TValue>::value, int>::type
static CFEXPBaseConvers::Compare(TValue value1, TValue value2, TValue eps)
//--------------------------------------------------------------------------------------
{
  if (eps == FEXPCOMMON_DEFAULT_VALUE)
    eps = GET_MIN_FLT_VAL(TValue);
  if (abs(value2 - value1) <= eps)
    return FEXPCOMMON_COMPARE_EQ;
  else if (value1 > value2)
    return FEXPCOMMON_COMPARE_1V;
  else if (value1 < value2)
    return FEXPCOMMON_COMPARE_2V;
  FEXPCOMMON_EXCEPTION("Error: Floating point comparision error!!!");
}

class ICFEXPValueConverterBase
{
public:
  virtual ~ICFEXPValueConverterBase() { }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

template<typename TValue>
class CFEXPValueConverter
  : public ICFEXPValueConverterBase
{
public:
  TValue GetValue(const std::string & text) { return CFEXPBaseConvers::StringToNumber<TValue>(text); }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// template specialization
template<>
class CFEXPValueConverter<std::string>
  : public ICFEXPValueConverterBase
{
public:
  std::string GetValue(const std::string & text) { return text; };
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

//https://stackoverflow.com/questions/18277304/using-stdcout-in-multiple-threads
class CFEXPSafeConcurencyConsolePrint
  : public std::ostringstream
{
public:
  CFEXPSafeConcurencyConsolePrint() = default;
  virtual ~CFEXPSafeConcurencyConsolePrint();
protected:
  // [no protected members] -----------------------------
private:
  static std::mutex _mtx_print;
};

class CFEXPLog
{
public:
  static void WriteLine(std::string line);
  static void WriteLine();
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

std::string GetModulePath();

std::string GetConfigPath(std::string fname) noexcept(false);

std::tuple<std::string, size_t, std::string, size_t>
GetCmdContent(int argc, char* argv[]) noexcept(false);

void TRACE(const char* format, ...);

#endif // !_CFEXPCOMMON_H_